home *** CD-ROM | disk | FTP | other *** search
/ Mixa 155: Dogs / MIXA 155: Dogs.iso / pc / Viewer / BROWSER(W) / フィルタ / PDF / LIB / gs_cmap.ps < prev    next >
Encoding:
Text File  |  2002-10-29  |  11.0 KB  |  363 lines
  1. %    Copyright (C) 1995, 2000 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This software is licensed to a single customer by Artifex Software Inc.
  4. % under the terms of a specific OEM agreement.
  5.  
  6. % $RCSfile: gs_cmap.ps,v $ $Revision: 1.10 $
  7. % ProcSet for implementing CMap resources.
  8. % When this is run, systemdict is still writable.
  9.  
  10. % NOTE: Rearranged fonts are not implemented yet.
  11.  
  12. % ---------------- Public operators ---------------- %
  13.  
  14. % composefont doesn't appear in CMap files -- it's documented in
  15. % the "PostScript Language Reference Manual Supplement".
  16. /composefont {        % <name> <cmap|cmapname> <fonts> composefont <font>
  17.   10 dict begin
  18.     /CMap 2 index dup type /dicttype ne { /CMap findresource } if def
  19.     /FDepVector 1 index cvlit def    % temporarily
  20.     /Encoding [ 0 1 FDepVector length 1 sub { } for ] def
  21.     /FDepVector [ 0 1 FDepVector length 1 sub {
  22.         % Stack: name cmap[name] fonts /FDepVector [ fonts... i
  23.       FDepVector 1 index get
  24.       dup type /dicttype ne {
  25.     dup /CIDFont resourcestatus {
  26.       pop pop /CIDFont
  27.     } {
  28.       /Font
  29.     } ifelse findresource
  30.       } if
  31.       exch CMap /FontMatrices get dup length 2 index gt {
  32.     exch get dup null eq { pop } { makefont } ifelse
  33.       } {
  34.     pop pop
  35.       } ifelse
  36.     } for ] readonly def
  37.     /FMapType 9 def
  38.     /FontMatrix matrix def
  39.     /FontName 3 index def
  40.     CMap /WMode .knownget { /WMode exch def } if
  41.     /FontType 0 def
  42.   pop pop currentdict end /Font defineresource
  43. } bind odef
  44.  
  45. % ---------------- CMap operators ---------------- %
  46.  
  47. 40 dict begin
  48.  
  49. % Our internal .CodeMapData structure closely mirrors the structures
  50. % defined in gxfcmap.h (q.v.).  () indicate a string, [] indicate an array,
  51. % ? indicates a Boolean, # indicates an integer, {} for grouping.
  52. %    [[(first) (last) ...]        % code space ranges
  53. %     [(prefix) (key_size,?is_range,value_type,value_size) (keys...)
  54. %       {(values...) | [value ...]} #font_index    % code mappings
  55. %      ...]
  56. %     <<same>>        % notdef mappings
  57. %    ]
  58. % FontMatrices is the array of matrices defined by begin/endusematrix.
  59. % All of the arrays and strings are read-only after they have been built.
  60. %
  61. % Note that the code in zfcmap.c that constructs the C structures from
  62. % the PostScript structures has intimate knowledge of the above format.
  63.  
  64. % ****** NOTE: The code currently only handles "well-behaved" CMaps:
  65. %    - CID values only (no bfchars), 16-bit
  66. %    - Entries (both code space and map) must be sorted
  67. %    - Only the last byte must vary in each map range, except for
  68. %    the identity mapping
  69.  
  70. % ------ Font-level operators ------ %
  71.  
  72. /begincmap {        % - begincmap -
  73.   /.CodeMapData [[] [] []] def
  74.   /FontMatrices [] def
  75.   /.FontIndex 0 def
  76.   /.TempMaps [20 dict 50 dict 50 dict] def
  77.   /CodeMap null def        % for .buildcmap
  78. } bind def
  79. /endcmap {        % - endcmap -
  80.   10 dict begin 0 1 2 {
  81.     /i exch def
  82.         % Append data from .TempMaps to .CodeMapData.
  83.     /t .TempMaps i get def
  84.     .CodeMapData i get length t { exch pop length add } forall
  85.     array /a exch def
  86.     a 0 .CodeMapData i get .putmore
  87.     0 1 t length 1 sub {
  88.       t exch get .putmore
  89.     } for pop pop
  90.     .CodeMapData i a put
  91.   } for end
  92.   currentdict /.TempMaps undef
  93.   /.CodeMapData .CodeMapData .endmap def
  94.   /FontMatrices FontMatrices .endmap def
  95. } bind def
  96.  
  97. /.putmore {        % <array> <i> <array2> .putmore <array> <i+len(array2)>
  98.   3 copy putinterval length add
  99. } bind def
  100.  
  101. /.endmap {        % <map> .endmap <map>
  102.   dup type /arraytype eq {
  103.     % This might be a shared read-only array inherited via usecmap.
  104.     % Don't try to update its elements if this is the case.
  105.     dup wcheck {
  106.       0 1 2 index length 1 sub {
  107.     2 copy 2 copy get .endmap put pop
  108.       } for readonly
  109.     } if
  110.   } {
  111.     dup type /stringtype eq { readonly } if
  112.   } ifelse
  113. } bind def
  114.  
  115. /.appendmap {        % -mark- <elt> ... <array#> .appendmap -
  116.   .TempMaps exch get counttomark 1 add 1 roll
  117.   ] 1 index length exch put
  118. } bind def
  119.  
  120. /begincodespacerange {    % <count> begincodespacerange -
  121.   pop mark
  122. } bind def
  123. /endcodespacerange {    % <code_lo> <code_hi> ... endcodespacerange -
  124.   0 .appendmap
  125. } bind def
  126.  
  127. /usecmap {        % <CMap_name> usecmap -
  128.   /CMap findresource dup
  129.         % Copy the top level of .CodeMapData
  130.   /.CodeMapData exch /.CodeMapData get copyarray def
  131.   /FontMatrices exch /FontMatrices get copyarray def
  132. } bind def
  133.  
  134. /usefont {        % <fontID> usefont -
  135.   /.FontIndex exch def
  136. } bind def
  137.  
  138. /beginusematrix {    % <fontID> beginusematrix -
  139.   FontMatrices wcheck not FontMatrices length 2 index le or {
  140.     FontMatrices length 1 index 1 add .max array
  141.     dup 0 FontMatrices putinterval
  142.     /FontMatrices exch def
  143.   } if
  144. } bind def
  145. /endusematrix {        % <matrix> endusematrix -
  146.   FontMatrices 3 1 roll put
  147. } bind def
  148.  
  149. % ------ Rearranged font operators ------ %
  150.  
  151. /beginrearrangedfont {    % <font_name> <font*> beginrearrangedfont -
  152.   10 dict begin
  153.   /.FontNames exch def
  154.   /.FontName exch def
  155.   begincmap
  156. } bind def
  157. /endrearrangedfont {    % - endrearrangedfont -
  158.   (REARRANGED FONTS NOT IMPLEMENTED YET.) = flush
  159.   FontName .FontNames 0 get findfont end definefont pop
  160. } bind def
  161.  
  162. % ------ Character name/code selector operators ------ %
  163.  
  164. /beginbfchar {        % <count> beginbfchar -
  165.   pop mark
  166. } bind def
  167. /endbfchar {        % <code> <to_code|charname> ... endbfchar
  168.   counttomark 2 idiv {
  169.     counttomark -2 roll        % process in correct order
  170.     .addbfchar
  171.   } repeat 1 .appendmap
  172. } bind def
  173.  
  174. /beginbfrange {        % <count> beginbfrange -
  175.   pop mark
  176. } bind def
  177. /endbfrange {        % <code_lo> <code_hi> <to_code|(charname*)> ...
  178.             %   endbfrange -
  179.   counttomark 3 idiv {
  180.     counttomark -3 roll        % process in correct order
  181.     dup type dup /arraytype eq exch /packedarraytype eq or {
  182.             % Array value, split up.
  183.       exch pop {
  184.             % Stack: code to_code|charname
  185.     1 index exch .addbfchar
  186.             % Increment the code.  As noted above, we require
  187.             % that only the last byte vary, but we still must
  188.             % mask it after incrementing, in case the last
  189.             % value was 0xff.
  190.             % Stack: code prefix params key value fontindex
  191.     6 -1 roll dup length string copy
  192.     dup dup length 1 sub 2 copy get 1 add 255 and put
  193.       } forall pop
  194.     } {
  195.             % Single value, handle directly.
  196.       .addbfrange
  197.     } ifelse
  198.   } repeat 1 .appendmap
  199. } bind def
  200.  
  201. /.addbfchar {        % <code> <to_code|charname> .addbfchar
  202.             %   <prefix> <params> <key> <value> <font_index>
  203.   1 index exch .addbfrange
  204. } bind def
  205. /.addbfrange {        % <code_lo> <code_hi> <to_code|charname>
  206.             %   .addbfrange <<same as .addbfchar>>
  207.   4 string dup 3
  208.   3 index type /nametype eq {
  209.     2 index 2 1 put
  210.     4 -1 roll 1 array astore 4 1 roll 4
  211.   } {
  212.     2 index 2 2 put
  213.     3 index length
  214.   } ifelse put
  215.             % Stack: code_lo code_hi value params
  216.   3 index 3 index eq {
  217.             % Single value.
  218.     3 -1 roll pop exch () exch
  219.   } {
  220.             % Range.
  221.     dup 0 1 put dup 1 1 put
  222.     4 2 roll
  223.     dup dup length 1 sub 0 exch getinterval 5 1 roll    % prefix
  224.             % Stack: prefix value params code_lo code_hi
  225.     2 { exch dup length 1 sub 1 getinterval } repeat concatstrings
  226.     3 -1 roll
  227.   } ifelse
  228.   .FontIndex
  229. } bind def
  230.  
  231. % ------ CID selector operators ------ %
  232.  
  233. /begincidchar {        % <count> begincidchar -
  234.   pop mark
  235. } bind def
  236. /endcidchar {        % <code> <cid> ... endcidchar -
  237.   1 .endmapchars
  238. } bind def
  239.  
  240. /begincidrange {    % <count> begincidrange -
  241.   pop mark
  242. } bind def
  243. /endcidrange {        % <code_lo> <code_hi> <cid_base> ... endcidrange -
  244.   1 .endmapranges
  245. } bind def
  246.  
  247. /.endmapchars {        % -mark- <code> <cid> ... <map#> .endmapchars -
  248.   counttomark 1 add 1 roll
  249.   counttomark 2 idiv {
  250.     counttomark -2 roll        % process in correct order
  251.         % Construct prefix, params, key, value, font_index
  252.     <00 00 00 02> ()    % params, key
  253.     3 -1 roll .endmapvalue
  254.   } repeat
  255.   counttomark 2 add -1 roll .appendmap
  256. } bind def
  257.  
  258. /.endmapranges {    % -mark- <code_lo> <code_hi> <cid_base> ... <map#>
  259.             %   .endmapranges -
  260.   counttomark 1 add 1 roll
  261.   counttomark 3 idiv {
  262.     counttomark -3 roll        % process in correct order
  263.         % Construct prefix, params, key_lo, key_hi, value, font_index
  264.     3 1 roll dup length 1 eq {
  265.       () 3 1 roll    % prefix
  266.       <01 01 00 02>    % params
  267.       3 1 roll        % keys
  268.       concatstrings 4 -1 roll .endmapvalue
  269.     } {
  270.         % Stack: cid_base code_lo code_hi
  271.         % Hack: handle 16-bit single-range mappings specially.
  272.       counttomark 3 eq 1 index length 2 eq and {
  273.     () 3 1 roll    % prefix
  274.     <02 01 00 02>    % params
  275.     3 1 roll    % keys
  276.     concatstrings 4 -1 roll .endmapvalue
  277.       } {
  278.     exch dup dup length 1 sub 0 exch getinterval    % prefix
  279.             % Stack: cid_base code_hi code_lo prefix
  280.     <01 01 00 02>    % params
  281.     3 -1 roll dup length 1 sub 1 getinterval    % key_lo
  282.     4 -1 roll dup length 1 sub 1 getinterval    % key_hi
  283.     concatstrings
  284.     4 -1 roll .endmapvalue
  285.         % See if we can merge with the previous value.
  286.         % The prefix, params, and font index must match.
  287.         % Stack: prefix params keys value fontindex
  288.     4 index 10 index eq        % prefix
  289.     4 index 10 index eq and    % params
  290.     1 index 7 index eq and    % fontindex
  291.     {
  292.       pop 4 2 roll pop pop
  293.         % Stack: prefix params keys value fontindex keys2 value2
  294.       5 -1 roll 3 -1 roll concatstrings
  295.         % Stack: prefix params value fontindex value2 keys'
  296.       4 -1 roll 3 -1 roll concatstrings
  297.         % Stack: prefix params fontindex keys' values'
  298.       3 -1 roll
  299.     } if
  300.       } ifelse
  301.     } ifelse
  302.   } repeat
  303.   counttomark 2 add -1 roll .appendmap
  304. } bind def
  305.  
  306. /.endmapvalue {        % <cid> .endmapvalue (hi,lo) .FontIndex
  307.   2 string dup 0 3 index -8 bitshift put    % value
  308.   dup 1 4 -1 roll 255 and put
  309.   .FontIndex        % font_index
  310. } bind def
  311.  
  312. % ------ notdef operators ------ %
  313.  
  314. /beginnotdefchar {    % <count> beginnotdefchar -
  315.   pop mark
  316. } bind def
  317. /endnotdefchar {    % <code> <cid> ... endnotdefchar -
  318.   2 .endmapchars
  319. } bind def
  320.  
  321. /beginnotdefrange {    % <count> beginnotdefrange -
  322.   pop mark
  323. } bind def
  324. /endnotdefrange {    % <code_lo> <code_hi> <cid> ... endnotdefrange -
  325.   2 .endmapranges
  326. } bind def
  327.  
  328. % ---------------- Resource category definition ---------------- %
  329.  
  330. currentdict end
  331.  
  332. languagelevel exch 2 .setlanguagelevel
  333.  
  334. /CMap /Generic /Category findresource dup length dict .copydict
  335. dup /InstanceType /dicttype put
  336. dup /DefineResource {
  337.         % The AdobePS5 Windows driver emits code that attempts to
  338.         % create CMaps without the required CMapName entry.
  339.         % Work around this here.
  340.   dup /CMapName known not {
  341.     dup wcheck not {
  342.       .currentglobal exch dup wcheck .setglobal
  343.       dup length dict .copydict exch .setglobal
  344.     } if
  345.     dup gcheck 2 index gcheck not and {
  346.       exch .currentglobal exch true .setglobal
  347.       dup length string copy exch .setglobal exch
  348.     } if dup /CMapName 3 index put
  349.   } if
  350.   dup /CodeMap get null eq { .buildcmap } if
  351.   /Generic /Category findresource /DefineResource get exec
  352. } put
  353. /Category defineresource pop
  354.     % We might have loaded CID font support already.
  355. /CIDInit /ProcSet 2 copy { findresource } .internalstopped
  356.     % An interior `stopped' might have reset VM allocation to local.
  357. true .setglobal
  358.  { pop pop 3 -1 roll }
  359.  { dup length 4 index length add dict .copydict 4 -1 roll exch .copydict }
  360. ifelse exch defineresource pop
  361.  
  362. .setlanguagelevel
  363.